Перейти к основному содержимому

5.16. Управляющие конструкции и операторы

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Управляющие конструкции и операторы​

Язык программирования Си предоставляет разработчику набор базовых инструментов для управления потоком выполнения программы. Эти инструменты позволяют выполнять определённые действия только при соблюдении заданных условий, повторять одни и те же операции многократно или выбирать один из нескольких возможных путей выполнения. Такие возможности реализуются с помощью управляющих конструкций и операторов.

Управляющие конструкции в Си — это синтаксические структуры, которые определяют порядок выполнения команд в зависимости от значений переменных, результатов вычислений или других условий. Они формируют основу логики любой программы, независимо от её сложности.

Условные конструкции: if и else​

Конструкция if позволяет выполнять блок кода только в том случае, если заданное условие истинно. Это одна из самых фундаментальных возможностей любого языка программирования.

Синтаксис простой формы if выглядит так:

if (условие) {
    // код, выполняемый при истинности условия
}

Условие — это выражение, результат которого интерпретируется как логическое значение. В Си любое целочисленное значение, отличное от нуля, считается истинным. Значение 0 считается ложным.

Пример:

int temperature = 25;

if (temperature > 20) {
    printf("Тепло.\n");
}

В этом примере строка "Тепло." будет выведена на экран, потому что значение переменной temperature больше 20.

Если требуется указать альтернативное действие на случай, когда условие ложно, используется конструкция else:

if (условие) {
    // действие при истинности
} else {
    // действие при ложности
}

Пример:

int age = 16;

if (age >= 18) {
    printf("Можно голосовать.\n");
} else {
    printf("Голосовать ещё нельзя.\n");
}

Здесь программа проверяет возраст и выводит соответствующее сообщение.

Для обработки нескольких условий подряд применяется цепочка else if:

if (условие1) {
    // действие 1
} else if (условие2) {
    // действие 2
} else if (условие3) {
    // действие 3
} else {
    // действие по умолчанию
}

Эта форма удобна, когда нужно выбрать один вариант из нескольких взаимоисключающих.

Пример:

int score = 85;

if (score >= 90) {
    printf("Отлично\n");
} else if (score >= 75) {
    printf("Хорошо\n");
} else if (score >= 60) {
    printf("Удовлетворительно\n");
} else {
    printf("Неудовлетворительно\n");
}

Каждое условие проверяется последовательно сверху вниз. Как только одно из них оказывается истинным, выполняется соответствующий блок, и остальные условия игнорируются.

Важно помнить, что фигурные скобки можно опустить, если тело конструкции состоит из одной строки. Однако такой стиль считается менее надёжным и читаемым, особенно в крупных проектах. Рекомендуется всегда использовать фигурные скобки, даже для одного оператора.

Множественный выбор: switch​

Конструкция switch предназначена для выбора одного из нескольких вариантов на основе значения целочисленного выражения или символа. Она работает как таблица переходов и часто применяется вместо длинных цепочек if-else if, когда все условия проверяют одно и то же выражение на равенство с разными константами.

Синтаксис:

switch (выражение) {
    case значение1:
        // действия
        break;
    case значение2:
        // действия
        break;
    default:
        // действия по умолчанию
}

Выражение внутри switch должно иметь целочисленный тип (int, char, перечисления и т.п.). Каждый case представляет собой метку, связанную с конкретным значением. Если значение выражения совпадает с одним из case, выполнение начинается с этой точки.

Оператор break завершает выполнение текущего case и передаёт управление за пределы конструкции switch. Без break выполнение «проваливается» в следующий case, что иногда используется намеренно, но чаще приводит к ошибкам.

Пример:

char grade = 'B';

switch (grade) {
    case 'A':
        printf("Отлично\n");
        break;
    case 'B':
        printf("Хорошо\n");
        break;
    case 'C':
        printf("Удовлетворительно\n");
        break;
    default:
        printf("Неизвестная оценка\n");
}

Вывод: Хорошо.

Если убрать break после case 'B', программа также выполнит case 'C' и выведет оба сообщения. Такое поведение называется «провалом» (fall-through) и требует особого внимания.

Метка default необязательна, но рекомендуется. Она обрабатывает все значения, не перечисленные явно в case.

Циклы: for, while, do-while​

Циклы позволяют многократно выполнять один и тот же блок кода. В Си существует три основных вида циклов: for, while и do-while. Все они решают похожие задачи, но имеют разные формы записи и области применения.

Цикл for​

Цикл for наиболее удобен, когда известно количество повторений заранее. Он объединяет три элемента: инициализацию, условие продолжения и изменение счётчика — в одной строке.

Синтаксис:

for (инициализация; условие; изменение) {
    // тело цикла
}

Порядок выполнения:

  1. Выполняется инициализация (один раз в начале).
  2. Проверяется условие.
  3. Если условие истинно, выполняется тело цикла.
  4. После тела выполняется изменение.
  5. Возвращаемся к шагу 2.

Пример:

for (int i = 0; i < 5; i++) {
    printf("Шаг %d\n", i);
}

Вывод:

Шаг 0
Шаг 1
Шаг 2
Шаг 3
Шаг 4

Переменная i инициализируется значением 0, проверяется условие i < 5, и после каждой итерации i увеличивается на 1.

Цикл for гибок: любая из трёх частей может быть опущена. Например, бесконечный цикл записывается как:

for (;;) {
    // бесконечное выполнение
}

Также можно управлять несколькими переменными одновременно:

for (int i = 0, j = 10; i < j; i++, j--) {
    printf("i=%d, j=%d\n", i, j);
}

Цикл while​

Цикл while проверяет условие до выполнения тела. Если условие ложно с самого начала, тело цикла не выполнится ни разу.

Синтаксис:

while (условие) {
    // тело цикла
}

Пример:

int count = 3;
while (count > 0) {
    printf("Обратный отсчёт: %d\n", count);
    count--;
}

Вывод:

Обратный отсчёт: 3
Обратный отсчёт: 2
Обратный отсчёт: 1

Цикл while подходит, когда количество итераций заранее неизвестно, но есть чёткое условие завершения.

Цикл do-while​

Цикл do-while отличается тем, что тело цикла выполняется хотя бы один раз, потому что проверка условия происходит после выполнения тела.

Синтаксис:

do {
    // тело цикла
} while (условие);

Пример:

int input;
do {
    printf("Введите число больше 10: ");
    scanf("%d", &input);
} while (input <= 10);

Этот код гарантирует, что пользователь введёт число хотя бы один раз, даже если сразу введёт корректное значение.

Цикл do-while часто используется в интерактивных программах, где требуется получить данные от пользователя до тех пор, пока они не будут удовлетворять требованиям.

Операторы в языке Си​

Операторы — это символы или комбинации символов, которые выполняют определённые действия над данными. В Си операторы делятся на несколько категорий в зависимости от типа выполняемых операций: арифметические, логические, побитовые, сравнения, присваивания и другие. Они составляют основу выражений, из которых строятся инструкции программы.

Арифметические операторы​

Арифметические операторы применяются для выполнения базовых математических операций над числами. Си поддерживает следующие арифметические операторы:

  • + — сложение
  • - — вычитание
  • * — умножение
  • / — деление
  • % — остаток от деления (деление по модулю)

Эти операторы работают с целыми и вещественными числами. Однако оператор % применим только к целочисленным типам (int, char, long и т.п.), потому что остаток от деления не определён для вещественных чисел.

Примеры:

int a = 10, b = 3;
int sum = a + b;        // 13
int diff = a - b;       // 7
int product = a * b;    // 30
int quotient = a / b;   // 3 (целочисленное деление)
int remainder = a % b;  // 1

Обратите внимание: при делении целых чисел результат также целый. Дробная часть отбрасывается, а не округляется.

Для получения точного результата деления необходимо использовать вещественные типы:

double x = 10.0, y = 3.0;
double result = x / y;  // примерно 3.333333

Существуют также инкремент (++) и декремент (--) — специальные операторы, увеличивающие или уменьшающие значение переменной на единицу. Они бывают двух форм: префиксной и постфиксной.

  • ++x — сначала увеличивает x, затем использует новое значение
  • x++ — сначала использует текущее значение x, затем увеличивает его

Пример:

int i = 5;
int a = ++i;  // i становится 6, a = 6
int b = i++;  // b = 6, затем i становится 7

Эти операторы часто встречаются в циклах и индексных выражениях.

Операторы сравнения​

Операторы сравнения используются для проверки отношений между двумя значениями. Результатом всегда является целое число: 1 (истина) или 0 (ложь).

Основные операторы сравнения:

  • == — равно
  • != — не равно
  • < — меньше
  • > — больше
  • <= — меньше или равно
  • >= — больше или равно

Пример:

int x = 7, y = 10;
printf("%d\n", x < y);   // 1
printf("%d\n", x == y);  // 0
printf("%d\n", x != y);  // 1

Эти операторы активно используются в условиях if, while, for и других управляющих конструкциях.

Важно не путать оператор присваивания = с оператором равенства ==. Ошибка вида if (x = 5) присваивает значение 5 переменной x и всегда даёт истинный результат (потому что 5 != 0). Современные компиляторы обычно предупреждают об этом, но ошибка остаётся частой среди начинающих.

Логические операторы​

Логические операторы позволяют комбинировать несколько условий в одно сложное выражение. В Си поддерживаются три логических оператора:

  • && — логическое И (AND)
  • || — логическое ИЛИ (OR)
  • ! — логическое НЕ (NOT)

Оператор && возвращает 1, только если оба операнда истинны.
Оператор || возвращает 1, если хотя бы один операнд истинен.
Оператор ! инвертирует значение: !0 даёт 1, !1 даёт 0.

Пример:

int age = 20;
int hasLicense = 1;

if (age >= 18 && hasLicense) {
    printf("Можно водить.\n");
}

if (age < 16 || age > 90) {
    printf("Возраст вне допустимого диапазона.\n");
}

Си использует ленивые вычисления (short-circuit evaluation):

  • В выражении A && B, если A ложно, B не вычисляется.
  • В выражении A || B, если A истинно, B не вычисляется.

Это поведение полезно для предотвращения ошибок. Например:

if (ptr != NULL && ptr->value > 0) {
    // Безопасный доступ к указателю
}

Если ptr равен NULL, вторая часть условия не будет проверена, и программа не завершится аварийно.

Побитовые операторы​

Побитовые операторы работают непосредственно с двоичным представлением чисел. Они применяются в системном программировании, работе с аппаратными регистрами, шифровании и оптимизации.

Основные побитовые операторы:

  • & — побитовое И
  • | — побитовое ИЛИ
  • ^ — побитовое исключающее ИЛИ (XOR)
  • ~ — побитовое НЕ (инверсия всех битов)
  • << — сдвиг влево
  • >> — сдвиг вправо

Примеры:

unsigned char a = 0b10101010;  // 170 в десятичной
unsigned char b = 0b11001100;  // 204

unsigned char and_result = a & b;  // 0b10001000
unsigned char or_result  = a | b;  // 0b11101110
unsigned char xor_result = a ^ b;  // 0b01100110
unsigned char not_a      = ~a;     // 0b01010101 (для 8 бит)

Операторы сдвига перемещают биты влево или вправо:

int x = 5;          // 0b00000101
int left = x << 1;  // 0b00001010 = 10
int right = x >> 1; // 0b00000010 = 2

Сдвиг влево на n позиций эквивалентен умножению на 2^n.
Сдвиг вправо на n позиций эквивалентен целочисленному делению на 2^n.

Побитовые операции особенно эффективны, когда нужно упаковать несколько флагов в одно число или работать с цветами, масками, сетевыми адресами.

Тернарный условный оператор (?:)​

Тернарный оператор — это компактная форма записи условия, возвращающая одно из двух значений в зависимости от результата проверки.

Синтаксис:

условие ? значение_если_истина : значение_если_ложь

Пример:

int a = 10, b = 20;
int max = (a > b) ? a : b;  // max = 20

Тернарный оператор часто используется для инициализации переменных или возврата значений в функциях:

char* getStatus(int score) {
    return (score >= 60) ? "Сдано" : "Не сдано";
}

Он может быть вложен:

int grade = (score >= 90) ? 5 :
            (score >= 75) ? 4 :
            (score >= 60) ? 3 : 2;

Хотя такая запись экономит место, чрезмерное вложение снижает читаемость. В таких случаях предпочтительнее использовать if-else.

Приоритет и ассоциативность операторов​

Когда в одном выражении участвует несколько операторов, порядок их выполнения определяется приоритетом и ассоциативностью.

Например, в выражении a + b * c сначала выполняется умножение, потому что у * выше приоритет, чем у +.

Полный порядок приоритетов в Си фиксирован, но запомнить его полностью сложно. Поэтому рекомендуется использовать круглые скобки для явного указания порядка вычислений, даже если они технически не обязательны.

Пример:

// Без скобок — трудно читать
if (a == b && c != d || e > f)

// Со скобками — понятно
if ((a == b && c != d) || (e > f))

Скобки не влияют на производительность, но значительно повышают надёжность и читаемость кода.

Совместное использование управляющих конструкций и операторов​

В реальных программах редко встречаются изолированные if или одиночные арифметические выражения. Гораздо чаще они комбинируются в сложные, но чёткие последовательности, которые обеспечивают корректную обработку данных при любых условиях.

Валидация пользовательского ввода​

Одна из самых частых задач — получение данных от пользователя и проверка их корректности. Это требует циклов и условий.

Пример: программа запрашивает возраст до тех пор, пока не будет введено значение от 0 до 120.

#include <stdio.h>

int main() {
    int age;
    do {
        printf("Введите ваш возраст (0–120): ");
        scanf("%d", &age);
    } while (age < 0 || age > 120);

    printf("Ваш возраст: %d\n", age);
    return 0;
}

Здесь цикл do-while гарантирует хотя бы один запрос. Логическое ИЛИ (||) в условии означает: «продолжать, если возраст меньше нуля или больше 120». Только когда оба условия ложны, цикл завершается.

Если требуется более строгая проверка (например, защита от ввода букв вместо чисел), используются дополнительные средства, такие как проверка возвращаемого значения scanf. Но даже в простом случае уже задействованы цикл, логические операторы и сравнение.

Обработка массивов​

Массивы — фундаментальная структура данных. Их обработка почти всегда требует циклов.

Пример: поиск максимального элемента в массиве.

#include <stdio.h>

int main() {
    int numbers[] = {34, 12, 78, 5, 92, 23};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    int max = numbers[0];  // предполагаем, что первый — максимум
    for (int i = 1; i < size; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
    }

    printf("Максимальное значение: %d\n", max);
    return 0;
}

Цикл for проходит по всем элементам, начиная со второго. Условие if сравнивает текущий элемент с текущим максимумом. Оператор присваивания обновляет максимум, если найден больший элемент.

Аналогично можно реализовать подсчёт суммы, среднего арифметического, количества чётных чисел и так далее.

Пример: подсчёт чётных чисел.

int countEven = 0;
for (int i = 0; i < size; i++) {
    if (numbers[i] % 2 == 0) {
        countEven++;
    }
}
printf("Чётных чисел: %d\n", countEven);

Здесь используется оператор % для проверки делимости на 2. Результат сравнения (== 0) управляет выполнением блока if.

Реализация меню с помощью switch​

Интерактивные программы часто строятся вокруг текстового меню. Конструкция switch идеально подходит для такой задачи.

#include <stdio.h>

int main() {
    int choice;
    do {
        printf("\n=== Меню ===\n");
        printf("1. Показать приветствие\n");
        printf("2. Показать время\n");
        printf("3. Выход\n");
        printf("Выберите действие: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("Здравствуйте!\n");
                break;
            case 2:
                printf("Текущее время: [заглушка]\n");
                break;
            case 3:
                printf("Выход...\n");
                break;
            default:
                printf("Неверный выбор. Попробуйте снова.\n");
        }
    } while (choice != 3);

    return 0;
}

Цикл do-while обеспечивает повторное отображение меню. Конструкция switch выбирает действие по номеру. Метка default обрабатывает некорректные вводы. Условие выхода — choice != 3.

Такая структура легко расширяется: достаточно добавить новый case и обновить текст меню.

Флаги и побитовые операции​

В системном программировании часто возникает задача хранения нескольких логических состояний в одном числе. Например, права доступа к файлу: чтение, запись, выполнение.

Побитовые операторы позволяют компактно управлять такими флагами.

#define READ   0b001  // 1
#define WRITE  0b010  // 2
#define EXEC   0b100  // 4

int permissions = READ | WRITE;  // разрешено чтение и запись

// Проверка: есть ли право на запись?
if (permissions & WRITE) {
    printf("Запись разрешена.\n");
}

// Добавление права на выполнение
permissions |= EXEC;

// Запрет записи
permissions &= ~WRITE;

Оператор | объединяет флаги.
Оператор & проверяет наличие флага.
Оператор ~ инвертирует биты, что позволяет «выключить» конкретный флаг с помощью &=.

Этот подход экономит память и ускоряет проверки, особенно в низкоуровневых системах.

Тернарный оператор в форматировании вывода​

Тернарный оператор удобен для динамического выбора значений без многострочных if.

Пример: согласование окончаний в русском языке.

int files = 5;
printf("Найдено %d файл%s.\n", files,
       (files == 1) ? "" :
       (files >= 2 && files <= 4) ? "а" : "ов");

Для files = 1 — «файл»,
для 2–4 — «файла»,
для остальных — «файлов».

Хотя это упрощённая модель (полная грамматика сложнее), пример демонстрирует, как тернарный оператор делает код компактным и выразительным.